#include<iostream>
using namespace std;

//class A
//{
//  public:
//    class B
//    {
//      private:
//        int _b1;
//    };
//  private:
//    int _a1;
//    int _a2;
//};
//
//
//int main()
//{
//    cout<<sizeof(A)<<endl;
//  return 0;
//}
//


///class A
/// {
/// public:
/// A(int a = 0)
/// :_a(a)
/// {
/// cout << "A(int a)" << endl;
///
///}
/// ~A()
/// {
/// cout << "~A()" << endl;
/// }
/// private:
/// int _a;
/// };
/// class Solution {
/// public:
/// int Sum_Solution(int n) {
/// //...
/// return n;
/// }
/// };
/// int main()
/// {
/// A aa1;
/// // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
/////A aa1();
/// // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
///// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
///A();
/// A aa2(2);
/// // 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
///Solution().Sum_Solution(10);
/// return 0;
/// }
///
//

//
//int main()
//{
////用法上便简介了
//  int *p1=new int;
//  int *p2=new int[10];
//  
//  delete p1;
//  delete  [] p2;//new的是[]就要delete[]
//  //都在堆上开辟空间
//  
//
//  //可以控制初始化
//  int *p3=new int(10);//new一个int，初始化为10
//  int *p4=new int[10]{1,2,3,4};//new10个int
//
//  
//  delete p3;
//  delete  [] p4;
//
//
//
//  return 0;
//}
//
//


struct ListNode
{
	ListNode* _next;
	int _val;

	ListNode(int val)
		:_next(nullptr)
		,_val(val)
	{}
};

struct ListNode* CreateListNode(int val)
{
	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->_next = NULL;
	newnode->_val = val;
	return newnode;
}

// 创建的不带哨兵位
ListNode* CreateList(int n)
{
	ListNode head(-1);  // 哨兵位

	ListNode* tail = &head;
	int val;
	printf("请依次输入%d个节点的值：>", n);
	for (size_t i = 0; i < n; i++)
	{
		cin >> val;
		tail->_next = new ListNode(val);
		tail = tail->_next;
	}

	return head._next;
}

void func()
{
	int n = 1;
	while (1)
	{
		int* p = new int[1024 * 1024*100];
		//int* p = (int*)malloc(1024 * 1024*4);

		cout <<n<<"->"<< p << endl;
		++n;
	}
}

int main()
{
	// 1、用法上，变简洁了
	int* p0 = (int*)malloc(sizeof(int));
	int* p1 = new int;
	int* p2 = new int[10]; // new 10个int对象

	// 2、可以控制初始化
	int* p3 = new int(10); // new 1个int对象,初始化成10
	int* p4 = new int[10]{ 1,2,3,4,5 };
	
	// 3、自定义类型，开空间+构造函数
	// 4、new失败了以后抛异常，不需要手动检查
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);
	//...
	//ListNode* list1 = CreateList(5);

	delete p3;
	delete[] p4;
	delete p1;
	delete[] p2;

	try
	{
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}
